package cn.edu.cug.cs.gtl.docsrv.shp.controller;


import cn.edu.cug.cs.gtl.docsrv.dict.exception.BaseException;
import cn.edu.cug.cs.gtl.docsrv.shp.catalog.CatalogTree;
import cn.edu.cug.cs.gtl.extractor.ShapeExtractor;
import cn.edu.cug.cs.gtl.mybatis.mapper.shp.ShpAll;
import cn.edu.cug.cs.gtl.docsrv.shp.service.ShpService;

import cn.edu.cug.cs.gtl.mybatis.mapper.shp.ShpCatalog;
import cn.edu.cug.cs.gtl.mybatis.metadata.ShpUtils;
import cn.edu.cug.cs.gtl.protos.Document;
import cn.edu.cug.cs.gtl.protos.DocumentList;
import cn.edu.cug.cs.gtl.protos.Tree;
import cn.edu.cug.cs.gtl.protos.TreeNode;
import cn.edu.cug.cs.gtl.tree.HashTree;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.google.protobuf.util.JsonFormat;
import org.geotools.geojson.geom.GeometryJSON;
import org.locationtech.jts.geom.Envelope;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

@RestController
@CrossOrigin
@RequestMapping(value = "/api")
public class ShpController {
    @Autowired
    ShpService shpService;
    /**
    服务编号：7001
    服务名称：addShp
    功能描述：单个本地Shp文件入库
    接口描述： /api/shp/addShp
    传入参数：
        ShpAll  shp；前端传入ShpAll的JSON对象
    返回值：
    成功返回true , 否则返回false
    调用示例：
     */
    @PostMapping(value = "/shp/addShp")
    public void addShp(
            @RequestParam(value = "data") String data){
        try {
            ShpAll shpAll = JSON.parseObject(data,ShpAll.class);
            if(shpAll!=null)
                shpService.addShp(shpAll);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7002
    服务名称：addShps
    功能描述：多个本地SHP文件入库
    接口描述： /api/shp/ addShps
    传入参数：
    List<ShpAll>  shps；前端传入ShpAll列表的JSON对象
    返回值：
    成功返回true , 否则返回false
    调用示例：
     */
    @PostMapping(value = "/shp/addShps")
    public void addShps(
            @RequestParam(value = "data") String data){
        try {
            ShpAllList shpAllList = JSON.parseObject(data,ShpAllList.class);
            if(shpAllList!=null)
                shpService.addShps(shpAllList.getShpAllList());
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7003
    服务名称：addFromRawDB
    功能描述：从原始数据库中提取指定类型的图形文件入库
    接口描述： /api/shp/addFromRawDB
    传入参数：
    String shpType   图形类型，文件后缀；
    返回值：
    成功返回true , 否则返回false
    调用示例：
    */
    @PostMapping(value = "/shp/addFromRawDB")
    public void addFromRawDB(@RequestParam(value = "shpType") String shpType){
        try {
            shpService.addFromRawDB();
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }

    /**
    服务编号：7004
    服务名称：getShpByName
    功能描述：图形数据库中提取指定名称的图形文件
    接口描述： /api/shp/getShpByName
    传入参数：
    String shpName   图形名称；
    返回值：
    List<ShpAll> shpAllList 的JSON字符串
    调用示例：
    */
    @GetMapping(value = "/shp/getShpByName")
    public List<ShpAll> getShpByName(@RequestParam(value = "shpName") String shpName){
        try {
            return shpService.getShpByName(shpName);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7005
    服务名称：getShpByEnTitle
    功能描述：图形数据库中提取指定英文名称的图形文件
    接口描述： /api/shp/ getShpByEnTitle
    传入参数：
    String shpEnTitle ；
    返回值：
    List<ShpAll> shpAllList 的JSON字符串
    调用示例：
     */
    @GetMapping(value = "/shp/getShpByEnTitle")
    public List<ShpAll> getShpByEnTitle(@RequestParam(value = "shpEnTitle") String shpEnTitle){
        try {
            return shpService.getShpByEnTitle(shpEnTitle);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7006
    服务名称：getShpByCnTitle
    功能描述：图形数据库中提取指定中文名称的图形文件
    接口描述： /api/shp/ getShpByCnTitle
    传入参数：
    String shpCnTitle ；
    返回值：
    List<ShpAll> shpAllList 的JSON字符串
    调用示例：
     */
    @GetMapping(value = "/shp/getShpByCnTitle")
    public List<ShpAll> getShpByCnTitle(@RequestParam(value = "shpCnTitle") String shpCnTitle){
        try {
            return shpService.getShpByEnTitle(shpCnTitle);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7007
    服务名称：getShpByInternalId
    功能描述：图形数据库中提取指定ID的图形文件
    接口描述： /api/shp/getShpByInternalId
    传入参数：
    long shpInternalId；
    返回值：
    ShpAll  shp     ; ShpAll的JSON字符串
    调用示例：
    */
    @GetMapping(value = "/shp/getShpByInternalId")
    public ShpAll getShpByInternalId(@RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            return shpService.getShpByInternalId(BigDecimal.valueOf(shpInternalId));
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7008
    服务名称：getShpByBoundingBox
    功能描述：图形数据库中提取指定范围的图形
    接口描述： /api/shp/getShpByBoundingBox
    传入参数：
    String bb；//minx,maxx,miny,maxy  数字之间逗号分隔
    String mask; //intersect 相交的图形； 或  contains 包含的图形
    返回值：
    List<ShpAll> shpAllList 的JSON字符串
    调用示例：
     */
    @GetMapping(value = "/shp/getShpByBoundingBox")
    public List<ShpAll> getShpByBoundingBox(
            @RequestParam(value = "shpBoundingBpx") String shpBoundingBpx,
            @RequestParam(value = "mask") String mask ){
        try {

            return shpService.getShpByBoundingBox(shpBoundingBpx,mask);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7009
    服务名称：deleteShpByInternalId
    功能描述：删除图形数据库中指定ID的图形
    接口描述： /api/shp/deleteShpByInternalId
    传入参数：
    long internalId；
    返回值：
    成功返回true , 否则返回false
    调用示例：
     */
    @PostMapping(value = "/shp/deleteShpByInternalId")
    public void deleteShpByInternalId(@RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            shpService.deleteShpByInternalId(BigDecimal.valueOf(shpInternalId));
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }



    /**
    服务编号：7010
    服务名称：getFeatureByBoundingBox
    功能描述：图形数据库中提取指定范围的要素
    接口描述： /api/shp/getFeatureByBoundingBox
    传入参数：
    String bb；//minx,maxx,miny,maxy  数字之间逗号分隔
    String mask; //intersect 相交的要素； 或  contains 包含的要素
    返回值：
    FeatureJSON的列表
    调用示例：
     */
    @GetMapping(value = "/shp/getFeatureByBoundingBox")
    public List<String> getFeatureByBoundingBox(
            @RequestParam(value = "shpBoundingBpx") String shpBoundingBpx,
            @RequestParam(value = "mask") String mask ){
        try {

            return shpService.getFeatureByBoundingBox(shpBoundingBpx,mask);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }




    /**
    服务编号：7011
    服务名称：getGeometryByBoundingBox
    功能描述：图形数据库中提取指定范围的几何对象
    接口描述： /api/shp/getGeometryByBoundingBox
    传入参数：
    String bb；//minx,maxx,miny,maxy  数字之间逗号分隔
    String mask; //intersect 相交的要素； 或  contains 包含的要素
    返回值：
    GeometryJSON的列表
    调用示例：
     */
    @GetMapping(value = "/shp/getGeometryByBoundingBox")
    public List<String> getGeometryByBoundingBox(
            @RequestParam(value = "shpBoundingBpx") String shpBoundingBpx,
            @RequestParam(value = "mask") String mask ){
        try {

            return shpService.getFeatureByBoundingBox(shpBoundingBpx,mask);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
    服务编号：7012
    服务名称：getGeometriesByShpInternalId
    功能描述：图形数据库中提取指定Shp的几何对象
    接口描述： /api/shp/getGeometriesByShpInternalId
    传入参数：
    long shpInternalId
    返回值：
    GeometryJSON的列表
    调用示例：
    */
    @GetMapping(value = "/shp/getGeometriesByShpInternalId")
    public List<String> getGeometriesByShpInternalId(
            @RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            return shpService.getGeometriesByShpInternalId(BigDecimal.valueOf(shpInternalId));
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     * 服务编号：7013
     * 服务名称：getEnvelopeByShpInternalId
     * 功能描述：图形数据库中提取指定范围的几何对象
     * 接口描述： /api/shp/getEnvelopeByShpInternalId
     * 传入参数：
     * long shpInternalId
     * 返回值：
     * Envelope
     * 调用示例：
     *
     * @param shpInternalId
     */
    @GetMapping(value = "/shp/getEnvelopeByShpInternalId")
    public String getEnvelopeByShpInternalId(
            @RequestParam(value = "shpInternalId") long shpInternalId) {
        Envelope e= shpService.getEnvelopeByShpInternalId(BigDecimal.valueOf(shpInternalId));
        GeometryJSON geometryJSON = new GeometryJSON();
        return geometryJSON.toString(e);
    }

    /**
     * 服务编号：7014
     * 服务名称：getShpCatalogs
     * 功能描述：图形数据库中提取所有分类
     * 接口描述： /api/shp/getShpCatalogs
     * 传入参数：
     * 返回值：
     * List<ShpCatalog> catalogs
     * 调用示例：
     */
    @GetMapping(value = "/shp/getShpCatalogs")
    public List<ShpCatalog> getShpCatalogs() {
        return shpService.getShpCatalogs();
    }


    /**
     服务编号：7015
     服务名称：getGeometriesByShpInternalId
     功能描述：图形数据库中提取指定Shp的几何对象
     接口描述： /api/shp/getFeaturesByShpInternalId
     传入参数：
     long shpInternalId
     返回值：
     FeatureJSON的列表
     调用示例：
     */
    @GetMapping(value = "/shp/getFeaturesByShpInternalId")
    public List<String> getFeaturesByShpInternalId(
            @RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            return shpService.getFeaturesByShpInternalId(BigDecimal.valueOf(shpInternalId));
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }

    /**
    服务编号：7016
    服务名称：getDocumentByShpInternalId
    功能描述：图形数据库中提取指定Shp文档
    接口描述： /api/shp/getDocumentByShpInternalId
    传入参数：
    long shpInternalId
    返回值：
    Document doc;
    其中，每个Feature的GeoJSON字符串为Document的一个content；
    其他的不为空的字段为该Shp文档的元数据。
    调用示例：
    http://localhost:8090/api/shp/getDocumentByShpInternalId?shpInternalId=3
     */
    @GetMapping(value = "/shp/getDocumentByShpInternalId")
    public byte[] getDocumentByShpInternalId(
            @RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            Document d= shpService.getDocumentByShpInternalId(BigDecimal.valueOf(shpInternalId));
            if(d!=null)
                return d.toByteArray();
            else
                return null;
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7017
     服务名称：addShpDocument
     功能描述：单个本地Shp文件入库,采用Document传递
     接口描述： /api/shp/addShpDocument
     传入参数：
        Document  shp；前端传入的和ShapAll对应的Document的字节数组
     返回值：
     成功返回true , 否则返回false
     调用示例：
     */
    @PostMapping(value = "/shp/addShpDocument")
    public void addShpDocument(@RequestBody  byte[] data){
        try {
            Document d = Document.parseFrom(data);
            if(d!=null){
                ShpAll shpAll = ShpUtils.convert(d);
                if(shpAll!=null)
                    shpService.addShp(shpAll);
            }
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7018
     服务名称：addShpDocuments
     功能描述：多个SHP文档入库
     接口描述： /api/shp/addShpDocuments
     传入参数：
        DocumentList  shps；DocumentList的字节数组
     返回值：
        成功返回true , 否则返回false
     调用示例：
     */
    @PostMapping(value = "/shp/addShpDocuments")
    public void addShpDocuments(@RequestBody  byte[] data){
        try {
            DocumentList dl = DocumentList.parseFrom(data);
            for(Document d:dl.getElementList()){
                if(d!=null){
                    ShpAll shpAll = ShpUtils.convert(d);
                    if(shpAll!=null)
                        shpService.addShp(shpAll);
                }
            }
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }



    /**
     服务编号：7019
     服务名称：getDocumentsByShpName
     功能描述：图形数据库中提取指定名称的图形文档
     接口描述： /api/shp/getDocumentsByShpName
     传入参数：
        String  shpName；
     返回值：
        DocumentList  shps；DocumentList的字节数组；
        其中每个Document的Contents存放1至多个FeatureJSON
     调用示例：
     */
    @GetMapping(value = "/shp/getDocumentsByShpName")
    public byte[] getDocumentsByShpName(@RequestParam(value = "shpName") String shpName){
        try {
            List<ShpAll> shpAllList= shpService.getShpByName(shpName);
            DocumentList.Builder documentListBuilder = DocumentList.newBuilder();
            for (ShpAll shpAll:shpAllList){
                Document doc = ShpUtils.convert(shpAll);
                documentListBuilder.addElement(doc);
            }
            return documentListBuilder.build().toByteArray();
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7020
     服务名称：getDocumentsByShpEnTitle
     功能描述：图形数据库中提取指定英文名称的图形文件
     接口描述： /api/shp/getDocumentsByShpEnTitle
     传入参数：
        String shpEnTitle ；
     返回值：
        DocumentList  shps；DocumentList的字节数组；
        其中每个Document的Contents存放1至多个FeatureJSON
     调用示例：
     */
    @GetMapping(value = "/shp/getDocumentsByShpEnTitle")
    public byte[] getDocumentsByShpEnTitle(@RequestParam(value = "shpEnTitle") String shpEnTitle){
        try {
            List<ShpAll> shpAllList= shpService.getShpByEnTitle(shpEnTitle);
            DocumentList.Builder documentListBuilder = DocumentList.newBuilder();
            for (ShpAll shpAll:shpAllList){
                Document doc = ShpUtils.convert(shpAll);
                documentListBuilder.addElement(doc);
            }
            return documentListBuilder.build().toByteArray();
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7021
     服务名称：getDocumentsByShpCnTitle
     功能描述：图形数据库中提取指定中文名称的图形文档
     接口描述： /api/shp/getDocumentsByShpCnTitle
     传入参数：
        String shpCnTitle ；
     返回值：
        DocumentList  shps；DocumentList的字节数组；
        其中每个Document的Contents存放1至多个FeatureJSON
     调用示例：
     */
    @GetMapping(value = "/shp/getDocumentsByShpCnTitle")
    public byte[] getDocumentsByShpCnTitle(@RequestParam(value = "shpCnTitle") String shpCnTitle){
        try {
            List<ShpAll> shpAllList= shpService.getShpByCnTitle(shpCnTitle);
            DocumentList.Builder documentListBuilder = DocumentList.newBuilder();
            for (ShpAll shpAll:shpAllList){
                Document doc = ShpUtils.convert(shpAll);
                documentListBuilder.addElement(doc);
            }
            return documentListBuilder.build().toByteArray();
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }




    /**
     服务编号：7023
     服务名称：getDocumentsByCatalogInternalId
     功能描述：图形数据库中提取指定分类ID的所有图形文档
     接口描述：/api/shp/getDocumentsByCatalogInternalId
     传入参数：
        long catalogInternalId
     返回值：
        DocumentList docList;
        其中，每个Feature的GeoJSON字符串为Document的一个content；
        其他的不为空的字段为该Shp文档的元数据。
     调用示例：
     http://localhost:8090/api/shp/getDocumentsByCatalogInternalId?catalogInternalId=3
     */
    @GetMapping(value = "/shp/getDocumentsByCatalogInternalId")
    public byte[] getDocumentsByCatalogInternalId(
            @RequestParam(value = "catalogInternalId") long catalogInternalId){
        try {
            DocumentList dl= shpService.getDocumentsByCatalogInternalId(BigDecimal.valueOf(catalogInternalId));
            if(dl!=null) {
                return dl.toByteArray();
            }
            else
                return null;
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7024
     服务名称：getCatalogTree
     功能描述：图形数据库中分类树
     接口描述：/api/shp/getCatalogTree
     传入参数：
     返回值：Tree   tree。
     调用示例：
     http://localhost:8090/api/shp/getCatalogTree
     */
    @GetMapping(value = "/shp/getCatalogTree")
    public byte[] getCatalogTree(){
        try {
            CatalogTree catalogTree = shpService.getCatalogTree();
            if(catalogTree!=null){
                Tree tree = catalogTree.cloneTree();
                if(tree!=null)
                    return tree.toByteArray();
            }
            return null;
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }

    /**
     服务编号：7025
     服务名称：getCatalogTreeJSON
     功能描述：图形数据库中分类树的JSON
     接口描述：/api/shp/getCatalogTreeJSON
     传入参数：
        返回值：Tree   tree 对于的JSON
     调用示例：
     http://localhost:8090/api/shp/getCatalogTreeJSON
     */
    @GetMapping(value = "/shp/getCatalogTreeJSON")
    public String getCatalogTreeJSON(){
        try {
            CatalogTree catalogTree = shpService.getCatalogTree();
            if(catalogTree!=null){
                Tree tree = catalogTree.cloneTree();
                if(tree!=null){
                    String sss = JsonFormat.printer().print(tree.toBuilder());
                    return sss;
                }
            }
            return null;
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }



    /**
     服务编号：7026
     服务名称：getShpInternalIdsByCatalogInternalId
     功能描述：图形数据库中提取指定分类ID的所有图形文档的ID
     接口描述：/api/shp/getShpInternalIdsByCatalogInternalId
     传入参数：
        long catalogInternalId
     返回值： String ShpInternalIds,
            JSONArray
            例如 "[1,2,3,4,5,6]"
     调用示例：
     http://localhost:8090/api/shp/getShpInternalIdsByCatalogInternalId?catalogInternalId=3
     */
    @GetMapping(value = "/shp/getShpInternalIdsByCatalogInternalId")
    public String getShpInternalIdsByCatalogInternalId(
            @RequestParam(value = "catalogInternalId") long catalogInternalId){
        try {
            List<BigDecimal> ls = shpService.getShpInternalIdsByCatalogInternalId(BigDecimal.valueOf(catalogInternalId));
            if(ls==null && ls.isEmpty()) return new String();

            int c = ls.size();
            long [] rs = new long[c];
            int i=0;
            for(BigDecimal b: ls) {
                rs[i] = b.longValue();
                ++i;
            }
            return JSONArray.toJSONString(rs);
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }


    /**
     服务编号：7027
     服务名称：getGeoJSONByShpInternalId
     功能描述：图形数据库中提取指定Shp文档的GeoJSON
     接口描述： /api/shp/getGeoJSONByShpInternalId
     传入参数：
        long shpInternalId
     返回值：
        GeoJSON;
     调用示例：
     http://localhost:8090/api/shp/getGeoJSONByShpInternalId?shpInternalId=3
     */
    @GetMapping(value = "/shp/getGeoJSONByShpInternalId")
    public String getGeoJSONByShpInternalId(
            @RequestParam(value = "shpInternalId") long shpInternalId){
        try {
            ShpAll shpAll = shpService.getShpByInternalId(BigDecimal.valueOf(shpInternalId));
            if (shpAll==null) return new String();
            return ShapeExtractor.parseToGeoJSON(shpAll.getShpRawBytes());
        } catch (Exception e) {
            throw new BaseException(e.getMessage());
        }
    }

//
//    @GetMapping(value = "/shp/greetings")
//    public List<ShpAll> greeting(
//            @RequestParam String name){
//        try{
//            List<ShpAll> res = new ArrayList<>();
//            ShpAll shpAll = new ShpAll();
//            shpAll.setShpUrl("bbbbb");
//            res.add(shpAll);
//            ShpAll shpAll1 = new ShpAll();
//            shpAll1.setShpUrl("cccccccc");
//            res.add(shpAll1);
//            return res;
//        }catch (Exception e){
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    @GetMapping(value = "/shp/getData")
//    public List<ShpItem> getShpData(){
//        try {
//            return shpService.getShpData();
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    @GetMapping(value = "/shp/getDataAll")
//    public List<ShpAll> getShpDataAll(){
//        try {
//            return shpService.getShpDataAll();
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    @PostMapping(value = "/shp/insertData")
//    public void insertShpData(
//            @RequestParam(value = "data") String data){
//        try {
//            byte [] bytes = Base64.getDecoder().decode(data);
//            Document document = Document.parseFrom(bytes);
//            ShpAll shpAll = ShpUtils.convert(document);
//            shpService.addShpData(shpAll);
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    @PostMapping(value = "/shp/deleteData")
//    public void deleteShpData(
//            @RequestParam(value = "data") String data) {
//        try {
//            byte [] bytes = Base64.getDecoder().decode(data);
//            Document document = Document.parseFrom(bytes);
//            ShpAll shpAll = ShpUtils.convert(document);
//            shpService.deleteShpData(shpAll);
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    @PostMapping(value = "/shp/updateData")
//    public void updateShpData(
//            @RequestParam(value = "data") String data) {
//        try {
//            byte [] bytes = Base64.getDecoder().decode(data);
//            Document document = Document.parseFrom(bytes);
//            ShpAll shpAll = ShpUtils.convert(document);
//            shpService.updateShpData(shpAll);
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    //    {
////        "docEnTitle":"Tom",
////        "docCnTitle":"勘查煲噶",
////        "docType":"doc"
////    }
//    @GetMapping(value = "/shp/query")
//    public List<ShpAll> query(
//            @RequestParam(value = "data") String data){
//        try {
//            byte [] bytes = Base64.getDecoder().decode(data);
//            Document document = Document.parseFrom(bytes);
//            ShpAll shpAll = ShpUtils.convert(document);
//            return  shpService.queryShpData(shpAll);
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
//
//    // application/x-msdownload;
//    @PostMapping(value = "/shp/downloadFile")
//    public void downloadShpFile(
//            @RequestParam(value = "docInternalId") BigDecimal shpInternalId,
//            HttpServletResponse response) throws Exception {
//        response.setContentType("application/x-msdownload; charset=utf-8");
//        response.setHeader("Content-Disposition", "attachment;filename=\"" + "\"");
//        try {
//            shpService.downloadShpFile(shpInternalId,response);
//        } catch (Exception e) {
//            throw new BaseException(e.getMessage());
//        }
//    }
}
